home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume2 / aplictns / dis6502.1 < prev    next >
Text File  |  1988-11-05  |  47KB  |  2,069 lines
  1. Path: xanth!nic.MR.NET!hal!cwjcc!mailrus!ulowell!page
  2. From: page@swan.ulowell.edu (Bob Page)
  3. Newsgroups: comp.sources.amiga
  4. Subject: v02i053:  dis6502 - disassemble 6502 object code
  5. Message-ID: <10051@swan.ulowell.edu>
  6. Date: 4 Nov 88 22:41:47 GMT
  7. Organization: University of Lowell, Computer Science Dept.
  8. Lines: 2058
  9. Approved: page@swan.ulowell.edu
  10.  
  11. Submitted-by: finkel@taurus.BITNET (Udi Finkelstein)
  12. Posting-number: Volume 2, Issue 53
  13. Archive-name: applications/dis6502.1
  14.  
  15. Dis6502 disassembles 6502 binary files.  Binary formats understood
  16. include C64, Atari and boot files.  Equate and control files can be
  17. included to name well-known locations and to control the disassembly
  18. process.  The output includes a cross reference.
  19.  
  20. #    This is a shell archive.
  21. #    Remove everything above and including the cut line.
  22. #    Then run the rest of the file through sh.
  23. #----cut here-----cut here-----cut here-----cut here----#
  24. #!/bin/sh
  25. # shar:    Shell Archiver
  26. #    Run the following text with /bin/sh to create:
  27. #    Makefile
  28. #    Makefile.unix
  29. #    c64.predefs
  30. #    dis.1
  31. #    dis.h
  32. #    dis.notes
  33. #    initopts.c
  34. #    lex.c
  35. #    lex.l
  36. #    main.c
  37. #    print.c
  38. #    ref.c
  39. #    tbl.c
  40. # This archive created: Fri Nov  4 17:33:09 1988
  41. cat << \SHAR_EOF > Makefile
  42. OBJS = main.o initopts.o lex.o ref.o print.o tbl.o
  43. SRCS = dis.h main.c initopts.c lex.l ref.c print.c tbl.c 
  44. CFLAGS = +p -n  -DAMIGA
  45.  
  46.  
  47. dis:        $(OBJS)
  48.         ln -g $(OBJS) -o dis -lcl32
  49.  
  50. tbl.o:        dis.h tbl.c
  51.  
  52. initopts.o:    dis.h initopts.c
  53.  
  54. main.o:        dis.h main.c
  55.  
  56. lex.c:        lex.l
  57.  
  58. lex.o:        lex.c dis.h
  59.  
  60. ref.o:        dis.h ref.c
  61.  
  62. print.o:    dis.h print.c
  63.  
  64. SHAR_EOF
  65. cat << \SHAR_EOF > Makefile.unix
  66. OBJS = main.o initopts.o lex.o ref.o print.o tbl.o
  67. SRCS = dis.h main.c initopts.c lex.l ref.c print.c tbl.c 
  68. CFLAGS = -O
  69.  
  70. dis:        $(OBJS)
  71.         cc $(OBJS) -o dis
  72.  
  73. tbl.o:        dis.h tbl.c
  74.         cc -c tbl.c
  75.  
  76. initopts.o:    dis.h initopts.c
  77.  
  78. main.o:        dis.h main.c
  79.  
  80. lex.o:        lex.c
  81.  
  82. lex.c:        dis.h lex.l
  83.  
  84. ref.o:        dis.h ref.c
  85.  
  86. print.o:    dis.h print.c
  87.  
  88. dis.man:    dis.1
  89.         nroff -man dis.1 > dis.man
  90.  
  91. install:    dis
  92.         cp dis /a/rgb/bin/dis6502
  93.  
  94. clean:
  95.         rm -f $(OBJS) lex.c dis.man
  96.  
  97. clobber:    clean
  98.         rm -f dis
  99.  
  100. ckpt:        $(SRCS)
  101.         ci -l $(SRCS)
  102.  
  103. lint: dis.h main.c initopts.c lex.c ref.c print.c tbl.c 
  104.         lint  dis.h main.c initopts.c lex.c ref.c print.c tbl.c 
  105.  
  106. shar:        Makefile dis.1 $(SRCS)
  107.         shar -f shar Makefile dis.1 $(SRCS)
  108. SHAR_EOF
  109. cat << \SHAR_EOF > c64.predefs
  110. 1    CINT        .EQ    $FF81
  111. 2    IOINIT        .EQ    $FF84
  112. 3    RAMTAS        .EQ    $FF87
  113. 4    RESTOR        .EQ    $FF8A
  114. 5    VECTOR        .EQ    $FF8D
  115. 6    SETMSG        .EQ    $FF90
  116. 7    SECOND        .EQ    $FF93
  117. 8    TKSA        .EQ    $FF96
  118. 9    MEMTOP        .EQ    $FF99
  119. 10    MEMBOT        .EQ    $FF9C
  120. 11    SCNKEY        .EQ    $FF9F
  121. 12    SETTMO        .EQ    $FFA2
  122. 13    ACPTR        .EQ    $FFA5
  123. 14    CIOUT        .EQ    $FFA8
  124. 15    UNTLK        .EQ    $FFAB
  125. 16    UNLSN        .EQ    $FFAE
  126. 17    LISTEN        .EQ    $FFB1
  127. 18    TALK        .EQ    $FFB4
  128. 19    READST        .EQ    $FFB7
  129. 20    SETLFS        .EQ    $FFBA
  130. 21    SETNAM        .EQ    $FFBD
  131. 22    OPEN        .EQ    $FFC0
  132. 23    CLOSE        .EQ    $FFC3
  133. 24    CHKIN        .EQ    $FFC6
  134. 25    CHKOUT        .EQ    $FFC9
  135. 26    CLRCHN        .EQ    $FFCC
  136. 27    CHRIN        .EQ    $FFCF
  137. 28    CHROUT        .EQ    $FFD2
  138. 29    LOAD        .EQ    $FFD5
  139. 30    SAVE        .EQ    $FFD8
  140. 31    SETTIM        .EQ    $FFDB
  141. 32    RDTIME        .EQ    $FFDE
  142. 33    STOP        .EQ    $FFE1
  143. 34    GETIN        .EQ    $FFE4
  144. 35    CLALL        .EQ    $FFE7
  145. 36    UDTIME        .EQ    $FFEA
  146. 37    SCREEN        .EQ    $FFED
  147. 38    PLOT        .EQ    $FFF0
  148. 39    IOBASE        .EQ    $FFF3
  149.  
  150. 40    IERRORLO    .EQ    $0300
  151. 41    IERRORHI    .EQ    $0301
  152. 42    IMAINLO        .EQ    $0302
  153. 43    IMAINHI        .EQ    $0303
  154. 44    ICRNCHLO    .EQ    $0304
  155. 45    ICRNCHHI    .EQ    $0305
  156. 46    IQPLOPLO    .EQ    $0306
  157. 47    IQPLOPHI    .EQ    $0307
  158. 48    IGONELO        .EQ    $0308
  159. 49    IGONEHI        .EQ    $0309
  160. 50    IEVALLO        .EQ    $030A
  161. 51    IEVALHI        .EQ    $030B
  162. 52    SAREG        .EQ    $030C
  163. 53    SXREG        .EQ    $030D
  164. 54    SYREG        .EQ    $030E
  165. 55    SPREG        .EQ    $030F
  166. 56    USRPOK        .EQ    $0310
  167. 57    USRADDLO    .EQ    $0311
  168. 58    USRADDHI    .EQ    $0312
  169. 59    CINVLO        .EQ    $0314
  170. 60    CINVHI        .EQ    $0315
  171. 61    CBINVLO        .EQ    $0316
  172. 62    CBINVHI        .EQ    $0317
  173. 63    NMINVLO        .EQ    $0318
  174. 64    NMINVHI        .EQ    $0319
  175. 65    IOPENLO        .EQ    $031A
  176. 66    IOPENHI        .EQ    $031B
  177. 67    ICLOSELO    .EQ    $031C
  178. 68    ICLOSEHI    .EQ    $031D
  179. 69    ICKINLO        .EQ    $031E
  180. 70    ICKINHI        .EQ    $031F
  181. 71    ICKOUTLO    .EQ    $0320
  182. 72    ICKOUTHI    .EQ    $0321
  183. 73    ICLRCHLO    .EQ    $0322
  184. 74    ICLRCHHI    .EQ    $0323
  185. 75    IBASINLO    .EQ    $0324
  186. 76    IBASINHI    .EQ    $0325
  187. 77    IBSOUTLO    .EQ    $0326
  188. 78    IBSOUTHI    .EQ    $0327
  189. 79    ISTOPLO        .EQ    $0328
  190. 80    ISTOPHI        .EQ    $0329
  191. 81    IGETINLO    .EQ    $032A
  192. 82    IGETINHI    .EQ    $032B
  193. 83    ICLALLLO    .EQ    $032C
  194. 84    ICLALLHI    .EQ    $032D
  195. 85    USRCMDLO    .EQ    $032E
  196. 86    USRCMDHI    .EQ    $032F
  197. 87    ILOADLO        .EQ    $0330
  198. 88    ILOADHI        .EQ    $0331
  199. 89    ISAVELO        .EQ    $0332
  200. 90    ISAVEHI        .EQ    $0333
  201.  
  202. 91    TBUFFER        .EQ    $033C
  203. 92    VICSCN        .EQ    $0400
  204. SHAR_EOF
  205. cat << \SHAR_EOF > dis.1
  206. .TH DIS6502 1 "1 OCT 1986"
  207. .UC 4
  208. .SH NAME
  209. dis6502 \- Disassemble 6502 object code
  210. .SH SYNOPSIS
  211. .I dis6502
  212. [
  213. .I \-b 
  214. ]
  215. [
  216. .I -p \fIpfile\fP 
  217. ]
  218. .I file
  219. .LP
  220. .SH DESCRIPTION
  221. .I  Dis6502
  222. disassembles 6502 binary files.  Binary formats understood include
  223. Atari binary files (L menu command) and boot files.
  224. Equate and control files can be included via the
  225. .I -p
  226. option to name well known locations and to control the disassembly
  227. process.  The output includes a cross reference.
  228. .PP
  229. The disassembly process is a two pass operation:  First the program
  230. flow is traced starting with the init and run parameters in the file
  231. headers.  The dump routine then prints out the information.
  232. .PP
  233. The command line options are:
  234. .TP
  235. .I \-b
  236. Assume that the file is a boot file, not a load file.
  237. .TP
  238. .I \-p \fIpfile\fP 
  239. Read in the predefine file \fIpfile\fP.
  240. Up to 20 \fI-p\fP options may be included.
  241. .PP
  242. Lines in pfile consist of:
  243. .PP
  244.  lineno name .eq number
  245. .PP
  246.  .stop number
  247. .PP
  248.  .trace number
  249. .PP 
  250. .I Lineno
  251. refers to a decimal number.  
  252. .I Number 
  253. may be a decimal number or
  254. may be a hexadecimal number (the first character of the number
  255. should be "$").  For example, "$21b5" is
  256. the hexadecimal number 21b5.
  257. .I Name
  258. is a sequence of numbers and characters starting with a
  259. letter.
  260. .I .trace 
  261. causes
  262. the trace process to continue at the address given.  
  263. .I .stop
  264. causes the
  265. trace process to stop at the address given.
  266. .SH AUTHOR
  267. Robert Bond
  268. .SH BUGS
  269. SHAR_EOF
  270. cat << \SHAR_EOF > dis.h
  271. #include <stdio.h>
  272.  
  273. #define NPREDEF 10
  274.  
  275. extern char *predef[];
  276. extern int  npredef;
  277. extern char *file;
  278. extern char *progname;
  279. extern int  bopt;
  280. #ifndef AMIGA
  281. extern unsigned char f[];
  282. extern unsigned char d[];
  283. #else
  284. extern unsigned char *d,*f;
  285. #endif
  286.  
  287. #define getword(x) (d[x] + (d[x+1] << 8))
  288. #define getbyte(x) (d[x])
  289.  
  290. /* f bits */
  291.  
  292. #define LOADED 1            /* Location loaded */
  293. #define JREF   2            /* Referenced as jump/branch dest */
  294. #define DREF   4            /* Referenced as data */
  295. #define SREF   8            /* Referenced as subroutine dest */
  296. #define NAMED  0x10            /* Has a name */
  297. #define TDONE  0x20            /* Has been traced */
  298. #define ISOP   0x40            /* Is a valid instruction opcode */
  299.  
  300. struct info {
  301.     char opn[4];
  302.     int  nb;
  303.     int  flag;
  304. };
  305.  
  306. extern struct info optbl[];
  307.  
  308. /* Flags */
  309.  
  310. /* Where control goes */
  311.  
  312. #define NORM 1
  313. #define JUMP 2
  314. #define FORK 4
  315. #define STOP 8
  316.  
  317. #define CTLMASK (NORM|JUMP|FORK|STOP)
  318.  
  319. /* Instruction format */
  320.  
  321. #define IMM  0x20
  322. #define ABS  0x40
  323. #define ACC  0x80
  324. #define IMP  0x100
  325. #define INX  0x200
  326. #define INY  0x400
  327. #define ZPX  0x800
  328. #define ABX  0x1000
  329. #define ABY  0x2000
  330. #define REL  0x4000
  331. #define IND  0x8000
  332. #define ZPY  0x10000
  333. #define ZPG  0x20000
  334. #define ILL  0x40000
  335.  
  336. #define ADRMASK (IMM|ABS|ACC|IMP|INX|INY|ZPX|ABX|ABY|REL|IND|ZPY|ZPG|ILL)
  337.  
  338. struct ref_chain {
  339.     struct ref_chain *next;
  340.     int who;
  341. };
  342.  
  343. struct ref_chain *get_ref();
  344. char *get_name();
  345.  
  346. /* lex junk */
  347.  
  348. #define EQ 256
  349. #define NUMBER 257
  350. #define NAME 258
  351. #define COMMENT 259
  352. #define LI 260
  353. #define TSTART 261
  354. #define TSTOP 262
  355.  
  356. extern FILE *yyin, *yyout;
  357. int lineno;
  358.  
  359. int yywrap(), yyerror();
  360. char *emalloc();
  361.  
  362. typedef union  {
  363.     int ival;
  364.     char *sval;
  365. } VALUE;
  366.  
  367. extern VALUE token;
  368. SHAR_EOF
  369. cat << \SHAR_EOF > dis.notes
  370.  
  371.  
  372.  
  373.        Some notes about Robert Bond's 'dis' program, Amiga version.
  374.  
  375.  
  376.  
  377. This  is a quick & dirty port of a 6502 reverse assembler I that I had under
  378. my  hand  for a long time.  I didn't bother optimizing the stuff too much, I
  379. just  wanted to see it working.  This is the sort of 'dirty' ports where you
  380. first  compiler  the  original file, then watch the compiler errors, and fix
  381. the errors in the file, without looking anywhere else in it.  Therefor:
  382.  
  383. 1)  'dis'  requires  C:Sort  (  too much bother to replace ) & C:Type ( I AM
  384.     lazy!!!)
  385.  
  386. 2)  I  still  don't  understand  why  are  the  line  numbers  needed in the
  387.     c64.predef file. I don't have much UNIX experience, and no experience at
  388.     all with lex. lex code is like chinese to  me, but  reading  the  perdef
  389.     I think that the line numbers are ignored and are used  only  to  easily
  390.     identify '.eq' lines.
  391.  
  392. 3)  The program  is recursive, too  much recursive!  the trace routine calls
  393.     itself not only on branches, but every instruction! large stacks (  even
  394.     50K isn't too much for large programs ), are welcomed... I  will  modify
  395.     this as soon as I'll have time. it should be easy to remove recursion in
  396.     the non branch/jmp instructions. branches must have recursion.
  397.  
  398. I also enhanced the original package, and added support for c64 binary file,
  399. which  wasn't there before.  ( It had only ATARI load/boot files ).  The C64
  400. file format was much simpler than those other 2 formats.  To select C64 file
  401. format, use the '-c' flag.  I also included a c64.predefs file with some C64
  402. constant  addresses.  Also, FYI, lex.c was generated on a SUN from lex.l and
  403. then downloaded to the Amiga.  lex.c was also __edited__ before compilation.
  404. I  know  that  it's  a  no-no  to  edit  machine-generated files, but it was
  405. necessary.
  406.  
  407.  
  408. Udi Finkelstein
  409.  
  410. 10 Glitzenstein st.
  411. Tel Aviv 64686 Israel
  412. Phone: 972-3-263-927
  413.  
  414. BITNET:     finkel@taurus.BITNET                     ( Best )
  415. UUCP:       ...!uunet!ulysses!attibr!althea!finkel   ( Try avoiding this )
  416. ARPA:       finkel%taurus@cunyvm.cuny.edu            ( Same as BITNET )
  417. FIDO:       Udi Finkelstein ( At 2:40/117 or 2:40/135
  418.                               If you can get there at all!)
  419. SHAR_EOF
  420. cat << \SHAR_EOF > initopts.c
  421.  
  422. /* 
  423.  * 
  424.  *  dis [-p predefineds] file
  425.  *
  426.  *  The -p option may be repeated.
  427.  */
  428.  
  429. #include "dis.h"
  430.  
  431. char *predef[NPREDEF];
  432. int  npredef = 0;
  433. char *file;
  434. char *progname = "dis";
  435. int  bopt = 0;
  436.  
  437. initopts(argc,argv)
  438. int argc;
  439. char *argv[];
  440. {
  441.     int ai;
  442.     char *ca;
  443.     int fileset = 0;
  444.  
  445.     progname = argv[0];
  446.  
  447.     while (--argc) {
  448.         if ((*++argv)[0] == '-') {
  449.         ca = *argv;
  450.         for(ai = 1; ca[ai] != '\0'; ai++)
  451.                 switch (ca[ai]) {
  452.                 case 'p':
  453.             predef[npredef] = *++argv;
  454.             npredef++;
  455.                     argc--;
  456.                     break;
  457.         case 'b':
  458.             bopt = 1;
  459.             break;
  460.  
  461.         case 'c':
  462.             bopt = 2;
  463.             break;
  464.                 default: crash("Invalid option letter");
  465.                 }
  466.         } else if (!fileset) {
  467.         file = *argv;
  468.         fileset++;
  469.     } else crash("Usage: [-{c|b}] [-p predef] file");
  470.     }
  471.     if (!fileset)
  472.      crash("Usage: [-{c|b}] [-p predef] file");
  473. }
  474. SHAR_EOF
  475. cat << \SHAR_EOF > lex.c
  476. # include "stdio.h"
  477. # define U(x) x
  478. # define NLSTATE yyprevious=YYNEWLINE
  479. # define BEGIN yybgin = yysvec + 1 +
  480. # define INITIAL 0
  481. # define YYLERR yysvec
  482. # define YYSTATE (yyestate-yysvec-1)
  483. # define YYOPTIM 1
  484. # define YYLMAX BUFSIZ
  485. # define output(c) putc(c,yyout)
  486. # define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
  487. # define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
  488. # define yymore() (yymorfg=1)
  489. # define ECHO fprintf(yyout, "%s",yytext)
  490. # define REJECT { nstr = yyreject(); goto yyfussy;}
  491. int yyleng; extern char yytext[];
  492. int yymorfg;
  493. extern char *yysptr, yysbuf[];
  494. int yytchar;
  495. FILE *yyin = {stdin}, *yyout = {stdout};
  496. extern int yylineno;
  497. struct yysvf { 
  498.     struct yywork *yystoff;
  499.     struct yysvf *yyother;
  500.     int *yystops;};
  501. struct yysvf *yyestate;
  502. extern struct yysvf yysvec[], *yybgin;
  503. #undef ECHO
  504. #include "dis.h"
  505. #ifndef AMIGA
  506. int lineno = 0;
  507. #endif
  508. char *strcpy();
  509. # define YYNEWLINE 10
  510. yylex(){
  511. int nstr; extern int yyprevious;
  512. while((nstr = yylook()) >= 0)
  513. yyfussy: switch(nstr){
  514. case 0:
  515. if(yywrap()) return(0); break;
  516. case 1:
  517. { ; }
  518. break;
  519. case 2:
  520. {    lineno++;
  521.                 return '\n';
  522. }
  523. break;
  524. case 3:
  525. { 
  526.                 return EQ;
  527. }
  528. break;
  529. case 4:
  530. { 
  531.                 return LI;
  532. }
  533. break;
  534. case 5:
  535. { 
  536.                 return EQ;
  537. }
  538. break;
  539. case 6:
  540. { 
  541.                 return LI;
  542. }
  543. break;
  544. case 7:
  545. {
  546.                 return TSTART;
  547. }
  548. break;
  549. case 8:
  550. {
  551.                 return TSTOP;
  552. }
  553. break;
  554. case 9:
  555. {
  556.                 (void)sscanf(yytext, "%d", &token.ival); 
  557.                 return NUMBER;
  558. }
  559. break;
  560. case 10:
  561. {
  562.                 (void)sscanf(yytext+1, "%x", &token.ival);
  563.                 return NUMBER;
  564. }
  565. break;
  566. case 11:
  567. {
  568.                 token.sval = emalloc((unsigned) strlen(yytext)+1);
  569.                 (void)strcpy((char *)token.sval, (char *)yytext);
  570.                 return NAME;
  571. }
  572. break;
  573. case 12:
  574. {
  575.                 return COMMENT;
  576. }
  577. break;
  578. case 13:
  579.         { return yytext[0]; }
  580. break;
  581. case -1:
  582. break;
  583. default:
  584. fprintf(yyout,"bad switch yylook %d",nstr);
  585. } return(0); }
  586. /* end of yylex */
  587.  
  588. char *
  589. emalloc(n)
  590. unsigned n;
  591. {
  592.     char *ptr, *malloc();
  593.  
  594.     if ((ptr = malloc(n)) == (char *) 0) {
  595.         (void) fprintf(stderr,"out of core");
  596.         exit(1);
  597.     }
  598.     return ptr;
  599. }
  600. int yyvstop[] = {
  601. 0,
  602.  
  603. 13,
  604. 0,
  605.  
  606. 1,
  607. 13,
  608. 0,
  609.  
  610. 2,
  611. 0,
  612.  
  613. 13,
  614. 0,
  615.  
  616. 12,
  617. 13,
  618. 0,
  619.  
  620. 13,
  621. 0,
  622.  
  623. 9,
  624. 13,
  625. 0,
  626.  
  627. 11,
  628. 13,
  629. 0,
  630.  
  631. 10,
  632. 0,
  633.  
  634. 12,
  635. 0,
  636.  
  637. 9,
  638. 0,
  639.  
  640. 11,
  641. 0,
  642.  
  643. 3,
  644. 0,
  645.  
  646. 4,
  647. 0,
  648.  
  649. 5,
  650. 0,
  651.  
  652. 6,
  653. 0,
  654.  
  655. 8,
  656. 0,
  657.  
  658. 7,
  659. 0,
  660. 0};
  661. # define YYTYPE char
  662. struct yywork { YYTYPE verify, advance; } yycrank[] = {
  663. 0,0,    0,0,    1,3,    0,0,    
  664. 0,0,    0,0,    0,0,    0,0,    
  665. 0,0,    0,0,    1,4,    1,5,    
  666. 0,0,    0,0,    0,0,    0,0,    
  667. 0,0,    0,0,    0,0,    0,0,    
  668. 7,12,    0,0,    0,0,    0,0,    
  669. 0,0,    0,0,    0,0,    0,0,    
  670. 7,12,    7,0,    12,0,    0,0,    
  671. 0,0,    0,0,    0,0,    0,0,    
  672. 0,0,    1,6,    2,6,    0,0,    
  673. 0,0,    0,0,    0,0,    1,7,    
  674. 2,7,    0,0,    0,0,    1,8,    
  675. 2,8,    1,9,    0,0,    0,0,    
  676. 0,0,    0,0,    0,0,    0,0,    
  677. 6,11,    6,11,    6,11,    6,11,    
  678. 6,11,    6,11,    6,11,    6,11,    
  679. 6,11,    6,11,    1,10,    7,12,    
  680. 0,0,    0,0,    0,0,    0,0,    
  681. 1,10,    6,11,    6,11,    6,11,    
  682. 6,11,    6,11,    6,11,    8,13,    
  683. 0,0,    0,0,    0,0,    0,0,    
  684. 7,12,    0,0,    8,14,    0,0,    
  685. 0,0,    0,0,    7,12,    0,0,    
  686. 0,0,    14,22,    0,0,    0,0,    
  687. 1,3,    0,0,    0,0,    0,0,    
  688. 0,0,    13,21,    0,0,    0,0,    
  689. 0,0,    6,11,    6,11,    6,11,    
  690. 6,11,    6,11,    6,11,    8,15,    
  691. 0,0,    0,0,    7,12,    0,0,    
  692. 0,0,    0,0,    8,16,    0,0,    
  693. 0,0,    0,0,    26,28,    0,0,    
  694. 0,0,    8,17,    8,18,    9,19,    
  695. 9,19,    9,19,    9,19,    9,19,    
  696. 9,19,    9,19,    9,19,    9,19,    
  697. 9,19,    10,20,    10,20,    10,20,    
  698. 10,20,    10,20,    10,20,    10,20,    
  699. 10,20,    10,20,    10,20,    15,23,    
  700. 16,24,    17,25,    18,26,    25,27,    
  701. 27,29,    28,30,    10,20,    10,20,    
  702. 10,20,    10,20,    10,20,    10,20,    
  703. 10,20,    10,20,    10,20,    10,20,    
  704. 10,20,    10,20,    10,20,    10,20,    
  705. 10,20,    10,20,    10,20,    10,20,    
  706. 10,20,    10,20,    10,20,    10,20,    
  707. 10,20,    10,20,    10,20,    10,20,    
  708. 30,31,    0,0,    0,0,    0,0,    
  709. 10,20,    0,0,    10,20,    10,20,    
  710. 10,20,    10,20,    10,20,    10,20,    
  711. 10,20,    10,20,    10,20,    10,20,    
  712. 10,20,    10,20,    10,20,    10,20,    
  713. 10,20,    10,20,    10,20,    10,20,    
  714. 10,20,    10,20,    10,20,    10,20,    
  715. 10,20,    10,20,    10,20,    10,20,    
  716. 0,0};
  717. struct yysvf yysvec[] = {
  718. 0,    0,    0,
  719. yycrank+-1,    0,        0,    
  720. yycrank+-2,    yysvec+1,    0,    
  721. yycrank+0,    0,        yyvstop+1,
  722. yycrank+0,    0,        yyvstop+3,
  723. yycrank+0,    0,        yyvstop+6,
  724. yycrank+8,    0,        yyvstop+8,
  725. yycrank+-19,    0,        yyvstop+10,
  726. yycrank+10,    0,        yyvstop+13,
  727. yycrank+79,    0,        yyvstop+15,
  728. yycrank+89,    0,        yyvstop+18,
  729. yycrank+0,    yysvec+6,    yyvstop+21,
  730. yycrank+-20,    yysvec+7,    yyvstop+23,
  731. yycrank+20,    0,        0,    
  732. yycrank+20,    0,        0,    
  733. yycrank+34,    0,        0,    
  734. yycrank+43,    0,        0,    
  735. yycrank+33,    0,        0,    
  736. yycrank+36,    0,        0,    
  737. yycrank+0,    yysvec+9,    yyvstop+25,
  738. yycrank+0,    yysvec+10,    yyvstop+27,
  739. yycrank+0,    0,        yyvstop+29,
  740. yycrank+0,    0,        yyvstop+31,
  741. yycrank+0,    0,        yyvstop+33,
  742. yycrank+0,    0,        yyvstop+35,
  743. yycrank+40,    0,        0,    
  744. yycrank+25,    0,        0,    
  745. yycrank+40,    0,        0,    
  746. yycrank+54,    0,        0,    
  747. yycrank+0,    0,        yyvstop+37,
  748. yycrank+79,    0,        0,    
  749. yycrank+0,    0,        yyvstop+39,
  750. 0,    0,    0};
  751. struct yywork *yytop = yycrank+211;
  752. struct yysvf *yybgin = yysvec+1;
  753. char yymatch[] = {
  754. 00  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  755. 01  ,011 ,012 ,01  ,01  ,01  ,01  ,01  ,
  756. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  757. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  758. 011 ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  759. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  760. '0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,
  761. '0' ,'0' ,01  ,01  ,01  ,01  ,01  ,01  ,
  762. 01  ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'G' ,
  763. 'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,
  764. 'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,
  765. 'G' ,'G' ,'G' ,01  ,01  ,01  ,01  ,'_' ,
  766. 01  ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'G' ,
  767. 'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,
  768. 'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,
  769. 'G' ,'G' ,'G' ,01  ,01  ,01  ,01  ,01  ,
  770. 0};
  771. char yyextra[] = {
  772. 0,0,0,0,0,0,0,0,
  773. 0,0,0,0,0,0,0,0,
  774. 0};
  775. #ifndef lint
  776. static    char ncform_sccsid[] = "@(#)ncform 1.2 86/10/08 SMI"; /* from S5R2 1.2 */
  777. #endif
  778.  
  779. int yylineno =1;
  780. # define YYU(x) x
  781. # define NLSTATE yyprevious=YYNEWLINE
  782. char yytext[YYLMAX];
  783. struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
  784. char yysbuf[YYLMAX];
  785. char *yysptr = yysbuf;
  786. int *yyfnd;
  787. extern struct yysvf *yyestate;
  788. int yyprevious = YYNEWLINE;
  789. yylook(){
  790.     register struct yysvf *yystate, **lsp;
  791.     register struct yywork *yyt;
  792.     struct yysvf *yyz;
  793.     int yych, yyfirst;
  794.     struct yywork *yyr;
  795. # ifdef LEXDEBUG
  796.     int debug;
  797. # endif
  798.     char *yylastch;
  799.     /* start off machines */
  800. # ifdef LEXDEBUG
  801.     debug = 0;
  802. # endif
  803.     yyfirst=1;
  804.     if (!yymorfg)
  805.         yylastch = yytext;
  806.     else {
  807.         yymorfg=0;
  808.         yylastch = yytext+yyleng;
  809.         }
  810.     for(;;){
  811.         lsp = yylstate;
  812.         yyestate = yystate = yybgin;
  813.         if (yyprevious==YYNEWLINE) yystate++;
  814.         for (;;){
  815. # ifdef LEXDEBUG
  816.             if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
  817. # endif
  818.             yyt = yystate->yystoff;
  819.             if(yyt == yycrank && !yyfirst){  /* may not be any transitions */
  820.                 yyz = yystate->yyother;
  821.                 if(yyz == 0)break;
  822.                 if(yyz->yystoff == yycrank)break;
  823.                 }
  824.             *yylastch++ = yych = input();
  825.             yyfirst=0;
  826.         tryagain:
  827. # ifdef LEXDEBUG
  828.             if(debug){
  829.                 fprintf(yyout,"char ");
  830.                 allprint(yych);
  831.                 putchar('\n');
  832.                 }
  833. # endif
  834.             yyr = yyt;
  835.             if ( (int)yyt > (int)yycrank){
  836.                 yyt = yyr + yych;
  837.                 if (yyt <= yytop && yyt->verify+yysvec == yystate){
  838.                     if(yyt->advance+yysvec == YYLERR)    /* error transitions */
  839.                         {unput(*--yylastch);break;}
  840.                     *lsp++ = yystate = yyt->advance+yysvec;
  841.                     goto contin;
  842.                     }
  843.                 }
  844. # ifdef YYOPTIM
  845.             else if((int)yyt < (int)yycrank) {        /* r < yycrank */
  846.                 yyt = yyr = yycrank+(yycrank-yyt);
  847. # ifdef LEXDEBUG
  848.                 if(debug)fprintf(yyout,"compressed state\n");
  849. # endif
  850.                 yyt = yyt + yych;
  851.                 if(yyt <= yytop && yyt->verify+yysvec == yystate){
  852.                     if(yyt->advance+yysvec == YYLERR)    /* error transitions */
  853.                         {unput(*--yylastch);break;}
  854.                     *lsp++ = yystate = yyt->advance+yysvec;
  855.                     goto contin;
  856.                     }
  857.                 yyt = yyr + YYU(yymatch[yych]);
  858. # ifdef LEXDEBUG
  859.                 if(debug){
  860.                     fprintf(yyout,"try fall back character ");
  861.                     allprint(YYU(yymatch[yych]));
  862.                     putchar('\n');
  863.                     }
  864. # endif
  865.                 if(yyt <= yytop && yyt->verify+yysvec == yystate){
  866.                     if(yyt->advance+yysvec == YYLERR)    /* error transition */
  867.                         {unput(*--yylastch);break;}
  868.                     *lsp++ = yystate = yyt->advance+yysvec;
  869.                     goto contin;
  870.                     }
  871.                 }
  872.             if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
  873. # ifdef LEXDEBUG
  874.                 if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
  875. # endif
  876.                 goto tryagain;
  877.                 }
  878. # endif
  879.             else
  880.                 {unput(*--yylastch);break;}
  881.         contin:
  882. # ifdef LEXDEBUG
  883.             if(debug){
  884.                 fprintf(yyout,"state %d char ",yystate-yysvec-1);
  885.                 allprint(yych);
  886.                 putchar('\n');
  887.                 }
  888. # endif
  889.             ;
  890.             }
  891. # ifdef LEXDEBUG
  892.         if(debug){
  893.             fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
  894.             allprint(yych);
  895.             putchar('\n');
  896.             }
  897. # endif
  898.         while (lsp-- > yylstate){
  899.             *yylastch-- = 0;
  900.             if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
  901.                 yyolsp = lsp;
  902.                 if(yyextra[*yyfnd]){        /* must backup */
  903.                     while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
  904.                         lsp--;
  905.                         unput(*yylastch--);
  906.                         }
  907.                     }
  908.                 yyprevious = YYU(*yylastch);
  909.                 yylsp = lsp;
  910.                 yyleng = yylastch-yytext+1;
  911.                 yytext[yyleng] = 0;
  912. # ifdef LEXDEBUG
  913.                 if(debug){
  914.                     fprintf(yyout,"\nmatch ");
  915.                     sprint(yytext);
  916.                     fprintf(yyout," action %d\n",*yyfnd);
  917.                     }
  918. # endif
  919.                 return(*yyfnd++);
  920.                 }
  921.             unput(*yylastch);
  922.             }
  923.         if (yytext[0] == 0  /* && feof(yyin) */)
  924.             {
  925.             yysptr=yysbuf;
  926.             return(0);
  927.             }
  928.         yyprevious = yytext[0] = input();
  929.         if (yyprevious>0)
  930.             output(yyprevious);
  931.         yylastch=yytext;
  932. # ifdef LEXDEBUG
  933.         if(debug)putchar('\n');
  934. # endif
  935.         }
  936.     }
  937. yyback(p, m)
  938.     int *p;
  939. {
  940. if (p==0) return(0);
  941. while (*p)
  942.     {
  943.     if (*p++ == m)
  944.         return(1);
  945.     }
  946. return(0);
  947. }
  948.     /* the following are only used in the lex library */
  949. yyinput(){
  950.     return(input());
  951.     }
  952. yyoutput(c)
  953.   int c; {
  954.     output(c);
  955.     }
  956. yyunput(c)
  957.    int c; {
  958.     unput(c);
  959.     }
  960. SHAR_EOF
  961. cat << \SHAR_EOF > lex.l
  962. %{
  963. #undef ECHO
  964. #include "dis.h"
  965. int lineno = 0;
  966. char *strcpy();
  967. %}
  968. %%
  969. [ \t] { ; }
  970. [\n] {    lineno++;
  971.                 return '\n';
  972. }
  973. \.EQ { 
  974.                 return EQ;
  975. }
  976. \.LI { 
  977.                 return LI;
  978. }
  979. \.eq { 
  980.                 return EQ;
  981. }
  982. \.li { 
  983.                 return LI;
  984. }
  985. ".trace" {
  986.                 return TSTART;
  987. }
  988. ".stop" {
  989.                 return TSTOP;
  990. }
  991. [0-9]+    {
  992.                 (void)sscanf(yytext, "%d", &token.ival); 
  993.                 return NUMBER;
  994. }
  995. \$[A-Fa-f0-9]+ {
  996.                 (void)sscanf(yytext+1, "%x", &token.ival);
  997.                 return NUMBER;
  998. }
  999. [A-Za-z][A-Za-z0-9_]* {
  1000.                 token.sval = emalloc((unsigned) strlen(yytext)+1);
  1001.                 (void)strcpy((char *)token.sval, (char *)yytext);
  1002.                 return NAME;
  1003. }
  1004. \*.* {
  1005.                 return COMMENT;
  1006. }
  1007. .            { return yytext[0]; }
  1008. %%
  1009.  
  1010. char *
  1011. emalloc(n)
  1012. unsigned n;
  1013. {
  1014.     char *ptr, *malloc();
  1015.  
  1016.     if ((ptr = malloc(n)) == (char *) 0) {
  1017.         (void) fprintf(stderr,"out of core");
  1018.         exit(1);
  1019.     }
  1020.     return ptr;
  1021. }
  1022. SHAR_EOF
  1023. cat << \SHAR_EOF > main.c
  1024. #include "dis.h"
  1025.  
  1026. #define NTSTART 20
  1027.  
  1028. char *cur_file = NULL;            /* the file thats open */
  1029. int  pre_index = 0;
  1030. int  tstart[NTSTART];            /* .trace directive keep locations */
  1031. int  tstarti = 0;
  1032.  
  1033. VALUE token;
  1034.  
  1035. #ifdef AMIGA
  1036. unsigned char *d,*f; /* Manx has a bug preventing us from declaring arrays >64K */
  1037. extern unsigned char *calloc();
  1038. #else
  1039. unsigned char d[0x10000];         /* The data */
  1040. unsigned char f[0x10000];        /* Flags for memory usage */ 
  1041. #endif
  1042.  
  1043. #define RUNLOC  0x2e0
  1044. #define INITLOC 0x2e2
  1045.  
  1046. main(argc, argv)
  1047. int argc;
  1048. char *argv[];
  1049. {
  1050.     int i;
  1051.  
  1052. #ifdef AMIGA
  1053. d = calloc(0x10000,1);
  1054. f = calloc(0x10000,1);
  1055. #endif
  1056.  
  1057.     initopts(argc, argv);
  1058.     if (npredef > 0) {
  1059.         cur_file = predef[0];
  1060.         pre_index++;
  1061.         yyin = fopen(cur_file, "r");
  1062.         if (!yyin)
  1063.             crash ("Cant open predefine file");
  1064.         get_predef();
  1065.     }
  1066.     switch (bopt) {
  1067.         case 0:
  1068.             loadboot();
  1069.             break;
  1070.         case 1:
  1071.             loadfile();
  1072.             break;
  1073.         case 2:
  1074.             c64loadfile();
  1075.             break;
  1076.         }
  1077.     for (i = 0; i<tstarti; i++)
  1078.         start_trace(tstart[i], "*PTRACE*");
  1079.  
  1080.     dumpitout();
  1081.  
  1082. #ifdef AMIGA
  1083. free(d);
  1084. free(f);
  1085. #endif
  1086.  
  1087.     exit(0);
  1088. }
  1089.  
  1090. crash(p)
  1091. char *p;
  1092. {
  1093.     fprintf(stderr, "%s: %s\n", progname, p);
  1094.     if (cur_file != NULL)
  1095.         fprintf(stderr, "Line %d of %s\n", lineno+1, cur_file);
  1096. #ifdef AMIGA
  1097. free(d);
  1098. free(f);
  1099. #endif
  1100.     exit(1);
  1101. }
  1102.  
  1103. get_predef()
  1104. {
  1105.     int loc;
  1106.     char *name;
  1107.  
  1108.     for(;;) 
  1109.         switch (yylex()) {
  1110.         case '\n':
  1111.             break;
  1112.         case 0:
  1113.             return;
  1114.         case TSTART:
  1115.             if (yylex() != NUMBER) 
  1116.                 crash(".trace needs a number operand");
  1117.             loc = token.ival;
  1118.             if (loc > 0x10000 || loc < 0)
  1119.                 crash("Number out of range");
  1120.             if (tstarti == NTSTART) 
  1121.                 crash("Too many .trace directives");
  1122.             tstart[tstarti++] = loc;
  1123.             while (yylex() != '\n')
  1124.                 ;
  1125.             break;
  1126.         case TSTOP:
  1127.             if (yylex() != NUMBER) 
  1128.                 crash(".stop needs a number operand");
  1129.             loc = token.ival;
  1130.             if (loc > 0x10000 || loc < 0)
  1131.                 crash("Number out of range");
  1132.             f[loc] |= TDONE;
  1133.             while (yylex() != '\n')
  1134.                 ;
  1135.             break;
  1136.         case NUMBER:
  1137.             switch (yylex()) {
  1138.             case LI:
  1139.             case COMMENT:
  1140.                 while (yylex() != '\n')
  1141.                     ;
  1142.                 break;
  1143.             case '\n':
  1144.                 break;
  1145.             case NAME:
  1146.                 name = token.sval;
  1147.                 if (yylex() != EQ) 
  1148.                     crash("Only EQ and LI supported in defines file");
  1149.                 if (yylex() != NUMBER)
  1150.                     crash("EQ operand must be a number");
  1151.                 loc = token.ival;
  1152.                 if (loc > 0x10000 || loc < 0)
  1153.                     crash("Number out of range");
  1154.                 f[loc] |= NAMED;
  1155.                 save_name(loc, name); 
  1156.                 while (yylex() != '\n') 
  1157.                     ;
  1158.                 break;
  1159.             default:
  1160.                 crash("Invalid line in predef file");
  1161.             }
  1162.             break;
  1163.         default:
  1164.             crash("Invalid line in predef file");
  1165.         }
  1166. }
  1167.  
  1168. loadboot()
  1169. {
  1170.     struct boot_hdr {
  1171.         unsigned char flags;
  1172.         unsigned char nsec;
  1173.         unsigned char base_low;
  1174.         unsigned char base_hi;
  1175.         unsigned char init_low;
  1176.         unsigned char init_hi;
  1177.     } bh;
  1178.  
  1179.     FILE *fp;
  1180.     int base_addr;
  1181.     register int i;
  1182.     int len;
  1183.  
  1184.     fp = fopen(file, "r");
  1185.     cur_file = NULL;
  1186.     if (!fp) { 
  1187.         fprintf(stderr, "Cant open %s\n", file);
  1188.  
  1189. #ifdef AMIGA
  1190. free(d);
  1191. free(f);
  1192. #endif
  1193.  
  1194.         exit(1);
  1195.     }
  1196.  
  1197.     if(fread((char *)&bh, sizeof(bh), 1, fp) != 1) 
  1198.         crash("Input too short");
  1199.     
  1200.     base_addr = bh.base_low + (bh.base_hi << 8);
  1201.     len = bh.nsec * 128;
  1202.     rewind(fp);
  1203.     if (fread((char *)&d[base_addr], 1, len, fp) != len) 
  1204.         crash("input too short");
  1205.  
  1206.     for(i = base_addr; len > 0; len--) 
  1207.         f[i++] |= LOADED;
  1208.  
  1209.     start_trace(base_addr+6, "**BOOT**");
  1210. }
  1211.  
  1212.  
  1213. loadfile()
  1214. {
  1215.     FILE *fp;
  1216.     int base_addr;
  1217.     int last_addr;
  1218.     register int i;
  1219.     int had_header;
  1220.     int tmp;
  1221.  
  1222.     had_header = 0;
  1223.     fp = fopen(file, "r");
  1224.     cur_file = NULL;
  1225.     if (!fp) { 
  1226.         fprintf(stderr, "Cant open %s\n", file);
  1227.  
  1228. #ifdef AMIGA
  1229. free(d);
  1230. free(f);
  1231. #endif
  1232.  
  1233.         exit(1);
  1234.     }
  1235.     for(;;) {
  1236.  
  1237.         i = getc(fp);
  1238.  
  1239.         if (i == EOF) {
  1240.             if (f[RUNLOC] & LOADED & f[RUNLOC+1]) {
  1241.                 i = getword(RUNLOC);
  1242.                 start_trace(i, "**RUN**");
  1243.             }
  1244.             return;
  1245.         }
  1246.  
  1247.         i = i | (getc(fp) << 8);
  1248.         if (i == 0xffff)  {
  1249.             had_header = 1;
  1250.             base_addr = getc(fp);
  1251.             base_addr = base_addr | (getc(fp) << 8);
  1252.             if (base_addr < 0 || base_addr > 0xffff) 
  1253.                 crash("Invalid base addr in input file");
  1254.         } else {
  1255.             if (!had_header)
  1256.                 crash("Invalid header in input file");
  1257.             base_addr = i;
  1258.         }
  1259.  
  1260.         last_addr = getc(fp);
  1261.         last_addr = last_addr | (getc(fp) << 8);
  1262.         if (last_addr < base_addr || last_addr > 0xffff) 
  1263.             crash("Invalid length in input file");
  1264.  
  1265.         printf("Load:  %4x -> %4x\n", base_addr, last_addr);
  1266.         for(i = base_addr; i <= last_addr; i++) {
  1267.             tmp = getc(fp);
  1268.             if (tmp == EOF) 
  1269.                 crash("File too small");
  1270.             d[i] = tmp;
  1271.             f[i] |= LOADED;
  1272.         }
  1273.  
  1274.         if (f[INITLOC] & LOADED & f[INITLOC+1])  {
  1275.             i = getword(INITLOC);
  1276.             start_trace(i, "**INIT**");
  1277.         }
  1278.  
  1279.         f[INITLOC] &= ~LOADED;
  1280.         f[INITLOC+1] &= ~LOADED;
  1281.     }
  1282.  
  1283. }
  1284.  
  1285.  
  1286. c64loadfile()
  1287. {
  1288.     FILE *fp;
  1289.     unsigned int base_addr,i;
  1290.     int c;
  1291.  
  1292.     fp = fopen(file, "r");
  1293.     cur_file = NULL;
  1294.     if (!fp) { 
  1295.         fprintf(stderr, "Cant open %s\n", file);
  1296.  
  1297. #ifdef AMIGA
  1298.         free(d);
  1299.         free(f);
  1300. #endif
  1301.  
  1302.         exit(1);
  1303.     }
  1304.  
  1305.     base_addr = getc(fp);
  1306.     i = ( base_addr += ( (unsigned int)getc(fp) << 8 ) );
  1307.  
  1308.     while( (c = getc(fp)) != EOF) {
  1309.         d[i] = c;
  1310.         f[i++] |= LOADED;
  1311.         }
  1312.  
  1313.     start_trace(base_addr, "**C64BIN**");
  1314. }
  1315.  
  1316.  
  1317. start_trace(loc, name)
  1318. unsigned int loc;
  1319. char *name;
  1320. {
  1321.     printf("Trace: %4x %s\n", loc, name);
  1322.     f[loc] |= (NAMED | SREF);
  1323.     if (!get_name(loc))
  1324.         save_name(loc, name);
  1325.     save_ref(0, loc);
  1326.     trace(loc);
  1327. }
  1328.     
  1329. trace(addr)
  1330. register unsigned int addr;
  1331. {
  1332.     int opcode;
  1333.     register struct info *ip; 
  1334.     int operand;
  1335.     int istart;
  1336.  
  1337.     if (f[addr] & TDONE)
  1338.         return;
  1339.     else 
  1340.         f[addr] |= TDONE;
  1341.  
  1342.     istart = addr;
  1343.     opcode = getbyte(addr);
  1344.     ip = &optbl[opcode];
  1345.  
  1346.     if (ip->flag & ILL)
  1347.         return;
  1348.  
  1349.     f[addr] |= ISOP;
  1350.  
  1351.     addr++;
  1352.  
  1353.     /* Get the operand */
  1354.  
  1355.     switch(ip->nb) {
  1356.         case 1:
  1357.             break;
  1358.         case 2:
  1359.             operand = getbyte(addr);
  1360.             f[addr++] |= TDONE;
  1361.             break;
  1362.         case 3:
  1363.             operand = getword(addr);
  1364.             f[addr++] |= TDONE;
  1365.             f[addr++] |= TDONE;
  1366.             break;
  1367.     }
  1368.  
  1369.     /* Mark data references */
  1370.  
  1371.     switch (ip->flag & ADRMASK) {
  1372.         case IMM:
  1373.         case ACC:
  1374.         case IMP:
  1375.         case REL:
  1376.         case IND:
  1377.             break;
  1378.         case ABS:
  1379.             if (ip->flag & (JUMP | FORK))
  1380.                 break;
  1381.             /* Fall into */
  1382.         case ABX:
  1383.         case ABY:
  1384.         case INX:
  1385.         case INY:
  1386.         case ZPG:
  1387.         case ZPX:
  1388.         case ZPY:
  1389.             f[operand] |= DREF;
  1390.             save_ref(istart, operand);
  1391.             break;
  1392.         default:
  1393.             crash("Optable error");
  1394.             break;
  1395.     }
  1396.  
  1397.     /* Trace the next instruction */
  1398.  
  1399.     switch (ip->flag & CTLMASK) {
  1400.         case NORM:
  1401.             trace(addr);
  1402.             break;
  1403.         case JUMP:
  1404.             f[operand] |= JREF;
  1405.             save_ref(istart, operand);
  1406.             trace(operand);
  1407.             break;
  1408.         case FORK:
  1409.             if (ip->flag & REL) {
  1410.                 if (operand > 127) 
  1411.                     operand = (~0xff | operand);
  1412.                 operand = operand + addr;
  1413.                 f[operand] |= JREF;
  1414.             } else {
  1415.                 f[operand] |= SREF;
  1416.             }
  1417.             save_ref(istart, operand);
  1418.             trace(operand);
  1419.             trace(addr);
  1420.             break;
  1421.         case STOP:
  1422.             break;
  1423.         default:
  1424.             crash("Optable error");
  1425.             break;
  1426.     }
  1427. }
  1428.  
  1429. int
  1430. yywrap()
  1431. {
  1432.     (void)fclose(yyin);
  1433.     if (npredef == pre_index) {
  1434.         return(1);
  1435.     } else  {
  1436.         lineno = 0;
  1437.         cur_file = predef[pre_index];
  1438.         pre_index++;
  1439.         yyin = fopen(cur_file, "r");
  1440.         if (!yyin) 
  1441.             crash("Can't open predefines file");
  1442.         return (0);
  1443.     }
  1444. }
  1445. SHAR_EOF
  1446. cat << \SHAR_EOF > print.c
  1447. #include <ctype.h>
  1448. #include "dis.h"
  1449.  
  1450. char *strcpy();
  1451. char *strcat();
  1452.  
  1453. dumpitout()
  1454. {
  1455.     int i;
  1456.  
  1457.     for(i = 0; i<0x10000;) {
  1458.         if (f[i] & LOADED) {
  1459.  
  1460.             if (f[i] & SREF && f[i] & ISOP)
  1461.                 printf("\n\n\n");
  1462.  
  1463.             printf("%04x  ",i);
  1464.             print_bytes(i);
  1465.             print_label(i);
  1466.             if (f[i] & ISOP)
  1467.                 i += print_inst(i);
  1468.             else
  1469.                 i += print_data(i);
  1470.             printf("\n");
  1471.  
  1472.         } else {
  1473.             i++;
  1474.         }
  1475.     }
  1476.  
  1477.     print_refs();
  1478. }
  1479.  
  1480. pchar(c)
  1481. int c;
  1482. {
  1483.     if (isascii(c) && isprint(c))
  1484.         return(c);
  1485.     return('.');
  1486. }
  1487.  
  1488. char *
  1489. lname(i)
  1490. int i;
  1491. {
  1492.     static char buf[20];
  1493.     char t;
  1494.  
  1495.     if (f[i] & NAMED) 
  1496.         return(get_name(i));
  1497.     if ((i > 0) && ((f[i-1] & (NAMED | DREF)) == (NAMED | DREF))) {
  1498.         (void)strcpy(buf, get_name(i-1));
  1499.         (void)strcat(buf, "+1");
  1500.         return (buf);
  1501.     }
  1502.     if (f[i] & SREF)
  1503.         t = 'S';
  1504.     else if (f[i] & JREF)
  1505.         t = 'L';
  1506.     else if (f[i] & DREF)
  1507.         t = 'D';
  1508.     else 
  1509.         t = 'X';
  1510.     
  1511.     (void)sprintf(buf, "%c%x", t, i);
  1512.     return (buf);
  1513. }
  1514.  
  1515. print_label(i)
  1516. {
  1517.     if (f[i] & (NAMED | JREF | SREF | DREF)) 
  1518.         printf("%-10s", lname(i));
  1519.     else
  1520.         printf("%10s"," ");
  1521. }
  1522.  
  1523. print_bytes(addr)
  1524. int addr;
  1525. {
  1526.     register struct info *ip; 
  1527.  
  1528.     if ((f[addr] & ISOP) == 0) {
  1529.         printf("           ");
  1530.         return;
  1531.     }
  1532.  
  1533.     ip = &optbl[getbyte(addr)];
  1534.  
  1535.     switch (ip->nb) {
  1536.         case 1:
  1537.             printf("%02x         ", getbyte(addr));
  1538.             break;
  1539.         case 2:
  1540.             printf("%02x %02x      ", getbyte(addr), getbyte(addr+1));
  1541.             break;
  1542.         case 3:
  1543.             printf("%02x %02x %02x   ", getbyte(addr), getbyte(addr+1), getbyte(addr+2));
  1544.             break;
  1545.     }
  1546. }
  1547.         
  1548.  
  1549. print_inst(addr)
  1550. int addr;
  1551. {
  1552.     int opcode;
  1553.     register struct info *ip; 
  1554.     int operand;
  1555.  
  1556.     opcode = getbyte(addr);
  1557.     ip = &optbl[opcode];
  1558.  
  1559.     printf("%s  ", ip->opn);
  1560.  
  1561.     addr++;
  1562.  
  1563.     switch(ip->nb) {
  1564.         case 1:
  1565.             break;
  1566.         case 2:
  1567.             operand = getbyte(addr);
  1568.             break;
  1569.         case 3:
  1570.             operand = getword(addr);
  1571.             break;
  1572.     }
  1573.  
  1574.     if (ip->flag & REL) {
  1575.         if (operand > 127) 
  1576.             operand = (~0xff | operand);
  1577.         operand = operand + ip->nb + addr - 1;
  1578.     }
  1579.  
  1580.     switch (ip->flag & ADRMASK) {
  1581.         case IMM:
  1582.             printf("#$%02x                        * %d %c", operand, operand, pchar(operand));
  1583.             break;
  1584.         case ACC:
  1585.         case IMP:
  1586.             break;
  1587.         case REL:
  1588.         case ABS:
  1589.         case ZPG:
  1590.             printf("%s ", lname(operand));
  1591.             break;
  1592.         case IND:
  1593.             printf("(%s) ", lname(operand));
  1594.             break;
  1595.         case ABX:
  1596.         case ZPX:
  1597.             printf("%s,X ", lname(operand));
  1598.             break;
  1599.         case ABY:
  1600.         case ZPY:
  1601.             printf("%s,Y ", lname(operand));
  1602.             break;
  1603.         case INX:
  1604.             printf("(%s,X) ", lname(operand));
  1605.             break;
  1606.         case INY:
  1607.             printf("(%s),Y", lname(operand));
  1608.             break;
  1609.         default:
  1610.             break;
  1611.     }
  1612.  
  1613.     return(ip->nb);
  1614.  
  1615. }
  1616.  
  1617. print_data(i)
  1618. {
  1619.     int count;
  1620.     int j;
  1621.     int start;
  1622.  
  1623.     start = i;
  1624.     printf(".DB  %02x ", getbyte(i));
  1625.     count = 1;
  1626.     i++;
  1627.  
  1628.     for (j = 1; j < 8; j++) {
  1629.         if (f[i] & (JREF | SREF | DREF) || ((f[i] & LOADED) == 0)) 
  1630.             break;
  1631.         else
  1632.             printf("%02x ", getbyte(i));
  1633.         i++;
  1634.         count++;
  1635.     }
  1636.     for (j = count; j < 8; j++)
  1637.         printf("   ");
  1638.  
  1639.     printf("    * ");
  1640.  
  1641.     for (j = start; j < i ; j++) 
  1642.             printf("%c", pchar((int)getbyte(j)));
  1643.  
  1644.     return (count);
  1645. }
  1646.  
  1647. print_refs()
  1648. {
  1649.     char tname[50];
  1650.     char cmd[200];
  1651.     FILE *fp;
  1652.     register struct ref_chain *rp;
  1653.     register int i;
  1654.     int npline;
  1655.  
  1656. #ifndef AMIGA
  1657.     (void)sprintf(tname, "dis.%d", getpid());
  1658.     (void)sprintf(cmd, "sort %s; rm %s", tname, tname);
  1659. #else
  1660.     (void)sprintf(tname, "dis.%ld", FindTask(0L));
  1661.     (void)sprintf(cmd, "Sort from %s to %s", tname, &tname[3] );
  1662. #endif
  1663.  
  1664.     fp = fopen(tname, "w");
  1665.     if (!fp) 
  1666.         crash("Cant open temporary file/n");
  1667.  
  1668.     for (i = 0; i<0x10000; i++) {
  1669.         if(f[i] & (JREF|SREF|DREF)) {
  1670.             rp = get_ref(i);
  1671.             if (!rp) {
  1672.                 fprintf(stderr, "No ref %d\n", i);
  1673.                 break;
  1674.             }
  1675.  
  1676.             fprintf(fp, "%-8s  %04x   ", lname(i), i);
  1677.             npline = 0;
  1678.             while (rp) {
  1679.                 fprintf(fp, "%04x ", rp->who);
  1680.                 npline++;
  1681.                 if (npline == 12) {
  1682.                     fprintf(fp,"\n");
  1683.                     fprintf(fp,"%-8s  %04x   ",lname(i),i);
  1684.                     npline = 0;
  1685.                 }
  1686.                 rp = rp->next;
  1687.             }
  1688.             fprintf(fp, "\n");
  1689.         }
  1690.  
  1691.     }
  1692.  
  1693.     (void)fclose(fp);
  1694.  
  1695.     printf("\n\n\n\n\nCross References\n\n");
  1696.     printf("%-8s  Value  References\n", "Symbol");
  1697.     (void)fflush (stdout);
  1698.  
  1699. #ifndef AMIGA
  1700.     (void)system(cmd);
  1701. #else
  1702.     (void)Execute(cmd,0L,0L);
  1703.     (void)sprintf(cmd, "Type %s",&tname[3]);
  1704.     (void)Execute(cmd,0L,Output());
  1705.     DeleteFile(tname);
  1706.     DeleteFile(&tname[3]);
  1707. #endif
  1708. }
  1709. SHAR_EOF
  1710. cat << \SHAR_EOF > ref.c
  1711. #include "dis.h"
  1712.  
  1713. #define HTSIZE 0x1000            /* Power of 2 */
  1714. #define HTMASK (HTSIZE-1)
  1715.  
  1716. struct hashslot {
  1717.     int addr;            /* The key */
  1718.     struct ref_chain *ref;        /* Who references it */
  1719.     char *name;            /* The symbolic name (if it has one) */
  1720. };
  1721.  
  1722. struct   hashslot hashtbl[HTSIZE];    /* the hash table */
  1723.  
  1724. struct hashslot *
  1725. hash(loc, allocate)
  1726. int loc;
  1727. int allocate;
  1728. {
  1729.     int probes;
  1730.     register struct hashslot *hp;
  1731.  
  1732.     hp = &hashtbl[loc & HTMASK];
  1733.     probes = 0;
  1734.  
  1735.     while (probes< HTSIZE) {
  1736.         if (hp->addr == loc)
  1737.             return(hp);
  1738.         if (hp->name == NULL && hp->ref == NULL) {
  1739.             if (allocate) {
  1740.                 hp->addr = loc;
  1741.                 return(hp);
  1742.             } else {
  1743.                 return(NULL);
  1744.             }
  1745.         }
  1746.         hp++;
  1747.         if (hp == &hashtbl[HTSIZE])
  1748.             hp = &hashtbl[0];
  1749.         probes++;
  1750.     }
  1751.  
  1752.     crash("Hash table full");
  1753.     /*NOTREACHED*/
  1754. }
  1755.  
  1756. save_ref(refer, refee) 
  1757. int refer;
  1758. int refee;
  1759. {
  1760.     struct ref_chain *rc;
  1761.     struct hashslot *hp;
  1762.  
  1763.     rc = (struct ref_chain *)emalloc(sizeof(*rc));
  1764.     rc->who = refer;
  1765.     hp = hash(refee, 1);
  1766.     rc->next = hp->ref;
  1767.     hp->ref = rc;
  1768. }
  1769.  
  1770. save_name(loc, name)
  1771. int loc;
  1772. char *name;
  1773. {
  1774.     struct hashslot *hp;
  1775.  
  1776.     hp = hash(loc, 1);
  1777.     hp->name = name;
  1778. }
  1779.  
  1780. struct ref_chain *
  1781. get_ref(loc)
  1782. {
  1783.     struct hashslot *hp;
  1784.  
  1785.     hp = hash(loc, 0);
  1786.     if (!hp) 
  1787.         return(NULL);
  1788.     return(hp->ref);
  1789. }
  1790.  
  1791. char *
  1792. get_name(loc)
  1793. {
  1794.     struct hashslot *hp;
  1795.  
  1796.     hp = hash(loc, 0);
  1797.     if (!hp) 
  1798.         return(NULL);
  1799.     return(hp->name);
  1800. }
  1801. SHAR_EOF
  1802. cat << \SHAR_EOF > tbl.c
  1803. #include "dis.h"
  1804.  
  1805. struct info optbl[256] = {
  1806.     /* 00 */    { { 'B', 'R', 'K', 0, },  1, IMP|STOP, },
  1807.     /* 01 */    { { 'O', 'R', 'A', 0, },  2, INX|NORM, },
  1808.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1809.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1810.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1811.     /* 05 */    { { 'O', 'R', 'A', 0, },  2, ZPG|NORM, },
  1812.     /* 06 */    { { 'A', 'S', 'L', 0, },  2, ZPG|NORM, },
  1813.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1814.     /* 08 */    { { 'P', 'H', 'P', 0, },  1, IMP|NORM, },
  1815.     /* 09 */    { { 'O', 'R', 'A', 0, },  2, IMM|NORM, },
  1816.     /* 0a */    { { 'A', 'S', 'L', 0, },  1, ACC|NORM, },
  1817.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1818.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1819.     /* 0d */    { { 'O', 'R', 'A', 0, },  3, ABS|NORM, },
  1820.     /* 0e */    { { 'A', 'S', 'L', 0, },  3, ABS|NORM, },
  1821.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1822.     /* 10 */    { { 'B', 'P', 'L', 0, },  2, REL|FORK, },
  1823.     /* 11 */    { { 'O', 'R', 'A', 0, },  2, INY|NORM, },
  1824.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1825.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1826.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1827.     /* 15 */    { { 'O', 'R', 'A', 0, },  2, ZPX|NORM, },
  1828.     /* 16 */    { { 'A', 'S', 'L', 0, },  2, ZPX|NORM, },
  1829.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1830.     /* 18 */    { { 'C', 'L', 'C', 0, },  1, IMP|NORM, },
  1831.     /* 19 */    { { 'O', 'R', 'A', 0, },  3, ABY|NORM, },
  1832.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1833.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1834.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1835.     /* 1d */    { { 'O', 'R', 'A', 0, },  3, ABX|NORM, },
  1836.     /* 1e */    { { 'A', 'S', 'L', 0, },  3, ABX|NORM, },
  1837.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1838.     /* 20 */    { { 'J', 'S', 'R', 0, },  3, ABS|FORK, },
  1839.     /* 21 */    { { 'A', 'N', 'D', 0, },  2, INX|NORM, },
  1840.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1841.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1842.     /* 24 */    { { 'B', 'I', 'T', 0, },  2, ZPG|NORM, },
  1843.     /* 25 */    { { 'A', 'N', 'D', 0, },  2, ZPG|NORM, },
  1844.     /* 26 */    { { 'R', 'O', 'L', 0, },  2, ZPG|NORM, },
  1845.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1846.     /* 28 */    { { 'P', 'L', 'P', 0, },  1, IMP|NORM, },
  1847.     /* 29 */    { { 'A', 'N', 'D', 0, },  2, IMM|NORM, },
  1848.     /* 2a */    { { 'R', 'O', 'L', 0, },  1, ACC|NORM, },
  1849.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1850.     /* 2c */    { { 'B', 'I', 'T', 0, },  3, ABS|NORM, },
  1851.     /* 2d */    { { 'A', 'N', 'D', 0, },  3, ABS|NORM, },
  1852.     /* 2e */    { { 'R', 'O', 'L', 0, },  3, ABS|NORM, },
  1853.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1854.     /* 30 */    { { 'B', 'M', 'I', 0, },  2, REL|FORK, },
  1855.     /* 31 */    { { 'A', 'N', 'D', 0, },  2, INY|NORM, },
  1856.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1857.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1858.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1859.     /* 35 */    { { 'A', 'N', 'D', 0, },  2, ZPX|NORM, },
  1860.     /* 36 */    { { 'R', 'O', 'L', 0, },  2, ZPX|NORM, },
  1861.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1862.     /* 38 */    { { 'S', 'E', 'C', 0, },  1, IMP|NORM, },
  1863.     /* 39 */    { { 'A', 'N', 'D', 0, },  3, ABY|NORM, },
  1864.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1865.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1866.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1867.     /* 3d */    { { 'A', 'N', 'D', 0, },  3, ABX|NORM, },
  1868.     /* 3e */    { { 'R', 'O', 'L', 0, },  3, ABX|NORM, },
  1869.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1870.     /* 40 */    { { 'R', 'T', 'I', 0, },  1, IMP|STOP, },
  1871.     /* 41 */    { { 'E', 'O', 'R', 0, },  2, INX|NORM, },
  1872.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1873.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1874.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1875.     /* 45 */    { { 'E', 'O', 'R', 0, },  2, ZPG|NORM, },
  1876.     /* 46 */    { { 'L', 'S', 'R', 0, },  2, ZPG|NORM, },
  1877.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1878.     /* 48 */    { { 'P', 'H', 'A', 0, },  1, IMP|NORM, },
  1879.     /* 49 */    { { 'E', 'O', 'R', 0, },  2, IMM|NORM, },
  1880.     /* 4a */    { { 'L', 'S', 'R', 0, },  1, ACC|NORM, },
  1881.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1882.     /* 4c */    { { 'J', 'M', 'P', 0, },  3, ABS|JUMP, },
  1883.     /* 4d */    { { 'E', 'O', 'R', 0, },  3, ABS|NORM, },
  1884.     /* 4e */    { { 'L', 'S', 'R', 0, },  3, ABS|NORM, },
  1885.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1886.     /* 50 */    { { 'B', 'V', 'C', 0, },  2, REL|FORK, },
  1887.     /* 51 */    { { 'E', 'O', 'R', 0, },  2, INY|NORM, },
  1888.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1889.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1890.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1891.     /* 55 */    { { 'E', 'O', 'R', 0, },  2, ZPX|NORM, },
  1892.     /* 56 */    { { 'L', 'S', 'R', 0, },  2, ZPX|NORM, },
  1893.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1894.     /* 58 */    { { 'C', 'L', 'I', 0, },  1, IMP|NORM, },
  1895.     /* 59 */    { { 'E', 'O', 'R', 0, },  3, ABY|NORM, },
  1896.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1897.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1898.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1899.     /* 5d */    { { 'E', 'O', 'R', 0, },  3, ABX|NORM, },
  1900.     /* 5e */    { { 'L', 'S', 'R', 0, },  3, ABX|NORM, },
  1901.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1902.     /* 60 */    { { 'R', 'T', 'S', 0, },  1, IMP|STOP, },
  1903.     /* 61 */    { { 'A', 'D', 'C', 0, },  2, INX|NORM, },
  1904.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1905.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1906.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1907.     /* 65 */    { { 'A', 'D', 'C', 0, },  2, ZPG|NORM, },
  1908.     /* 66 */    { { 'R', 'O', 'R', 0, },  2, ZPG|NORM, },
  1909.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1910.     /* 68 */    { { 'P', 'L', 'A', 0, },  1, IMP|NORM, },
  1911.     /* 69 */    { { 'A', 'D', 'C', 0, },  2, IMM|NORM, },
  1912.     /* 6a */    { { 'R', 'O', 'R', 0, },  1, ACC|NORM, },
  1913.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1914.     /* 6c */    { { 'J', 'M', 'P', 0, },  3, IND|STOP, },
  1915.     /* 6d */    { { 'A', 'D', 'C', 0, },  3, ABS|NORM, },
  1916.     /* 6e */    { { 'R', 'O', 'R', 0, },  3, ABS|NORM, },
  1917.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1918.     /* 70 */    { { 'B', 'V', 'S', 0, },  2, REL|FORK, },
  1919.     /* 71 */    { { 'A', 'D', 'C', 0, },  2, INY|NORM, },
  1920.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1921.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1922.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1923.     /* 75 */    { { 'A', 'D', 'C', 0, },  2, ZPX|NORM, },
  1924.     /* 76 */    { { 'R', 'O', 'R', 0, },  2, ZPX|NORM, },
  1925.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1926.     /* 78 */    { { 'S', 'E', 'I', 0, },  1, IMP|NORM, },
  1927.     /* 79 */    { { 'A', 'D', 'C', 0, },  3, ABY|NORM, },
  1928.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1929.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1930.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1931.     /* 7d */    { { 'A', 'D', 'C', 0, },  3, ABX|NORM, },
  1932.     /* 7e */    { { 'R', 'O', 'R', 0, },  3, ABX|NORM, },
  1933.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1934.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1935.     /* 81 */    { { 'S', 'T', 'A', 0, },  2, INX|NORM, },
  1936.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1937.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1938.     /* 84 */    { { 'S', 'T', 'Y', 0, },  2, ZPG|NORM, },
  1939.     /* 85 */    { { 'S', 'T', 'A', 0, },  2, ZPG|NORM, },
  1940.     /* 86 */    { { 'S', 'T', 'X', 0, },  2, ZPG|NORM, },
  1941.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1942.     /* 88 */    { { 'D', 'E', 'Y', 0, },  1, IMP|NORM, },
  1943.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1944.     /* 8a */    { { 'T', 'X', 'A', 0, },  1, IMP|NORM, },
  1945.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1946.     /* 8c */    { { 'S', 'T', 'Y', 0, },  3, ABS|NORM, },
  1947.     /* 8d */    { { 'S', 'T', 'A', 0, },  3, ABS|NORM, },
  1948.     /* 8e */    { { 'S', 'T', 'X', 0, },  3, ABS|NORM, },
  1949.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1950.     /* 90 */    { { 'B', 'C', 'C', 0, },  2, REL|FORK, },
  1951.     /* 91 */    { { 'S', 'T', 'A', 0, },  2, INY|NORM, },
  1952.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1953.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1954.     /* 94 */    { { 'S', 'T', 'Y', 0, },  2, ZPX|NORM, },
  1955.     /* 95 */    { { 'S', 'T', 'A', 0, },  2, ZPX|NORM, },
  1956.     /* 96 */    { { 'S', 'T', 'X', 0, },  2, ZPY|NORM, },
  1957.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1958.     /* 98 */    { { 'T', 'Y', 'A', 0, },  1, IMP|NORM, },
  1959.     /* 99 */    { { 'S', 'T', 'A', 0, },  3, ABY|NORM, },
  1960.     /* 9a */    { { 'T', 'X', 'S', 0, },  1, IMP|NORM, },
  1961.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1962.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1963.     /* 9d */    { { 'S', 'T', 'A', 0, },  3, ABX|NORM, },
  1964.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1965.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1966.     /* a0 */    { { 'L', 'D', 'Y', 0, },  2, IMM|NORM, },
  1967.     /* a1 */    { { 'L', 'D', 'A', 0, },  2, INX|NORM, },
  1968.     /* a2 */    { { 'L', 'D', 'X', 0, },  2, IMM|NORM, },
  1969.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1970.     /* a4 */    { { 'L', 'D', 'Y', 0, },  2, ZPG|NORM, },
  1971.     /* a5 */    { { 'L', 'D', 'A', 0, },  2, ZPG|NORM, },
  1972.     /* a6 */    { { 'L', 'D', 'X', 0, },  2, ZPG|NORM, },
  1973.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1974.     /* a8 */    { { 'T', 'A', 'Y', 0, },  1, IMP|NORM, },
  1975.     /* a9 */    { { 'L', 'D', 'A', 0, },  2, IMM|NORM, },
  1976.     /* aa */    { { 'T', 'A', 'X', 0, },  1, IMP|NORM, },
  1977.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1978.     /* ac */    { { 'L', 'D', 'Y', 0, },  3, ABS|NORM, },
  1979.     /* ad */    { { 'L', 'D', 'A', 0, },  3, ABS|NORM, },
  1980.     /* ae */    { { 'L', 'D', 'X', 0, },  3, ABS|NORM, },
  1981.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1982.     /* b0 */    { { 'B', 'C', 'S', 0, },  2, REL|FORK, },
  1983.     /* b1 */    { { 'L', 'D', 'A', 0, },  2, INY|NORM, },
  1984.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1985.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1986.     /* b4 */    { { 'L', 'D', 'Y', 0, },  2, ZPX|NORM, },
  1987.     /* b5 */    { { 'L', 'D', 'A', 0, },  2, ZPX|NORM, },
  1988.     /* b6 */    { { 'L', 'D', 'X', 0, },  2, ZPY|NORM, },
  1989.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1990.     /* b8 */    { { 'C', 'L', 'V', 0, },  1, IMP|NORM, },
  1991.     /* b9 */    { { 'L', 'D', 'A', 0, },  3, ABY|NORM, },
  1992.     /* ba */    { { 'T', 'S', 'X', 0, },  1, IMP|NORM, },
  1993.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1994.     /* bc */    { { 'L', 'D', 'Y', 0, },  3, ABX|NORM, },
  1995.     /* bd */    { { 'L', 'D', 'A', 0, },  3, ABX|NORM, },
  1996.     /* be */    { { 'L', 'D', 'X', 0, },  3, ABY|NORM, },
  1997.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1998.     /* c0 */    { { 'C', 'P', 'Y', 0, },  2, IMM|NORM, },
  1999.     /* c1 */    { { 'C', 'M', 'P', 0, },  2, INX|NORM, },
  2000.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2001.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2002.     /* c4 */    { { 'C', 'P', 'Y', 0, },  2, ZPG|NORM, },
  2003.     /* c5 */    { { 'C', 'M', 'P', 0, },  2, ZPG|NORM, },
  2004.     /* c6 */    { { 'D', 'E', 'C', 0, },  2, ZPG|NORM, },
  2005.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2006.     /* c8 */    { { 'I', 'N', 'Y', 0, },  1, IMP|NORM, },
  2007.     /* c9 */    { { 'C', 'M', 'P', 0, },  2, IMM|NORM, },
  2008.     /* ca */    { { 'D', 'E', 'X', 0, },  1, IMP|NORM, },
  2009.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2010.     /* cc */    { { 'C', 'P', 'Y', 0, },  3, ABS|NORM, },
  2011.     /* cd */    { { 'C', 'M', 'P', 0, },  3, ABS|NORM, },
  2012.     /* ce */    { { 'D', 'E', 'C', 0, },  3, ABS|NORM, },
  2013.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2014.     /* d0 */    { { 'B', 'N', 'E', 0, },  2, REL|FORK, },
  2015.     /* d1 */    { { 'C', 'M', 'P', 0, },  2, INY|NORM, },
  2016.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2017.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2018.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2019.     /* d5 */    { { 'C', 'M', 'P', 0, },  2, ZPX|NORM, },
  2020.     /* d6 */    { { 'D', 'E', 'C', 0, },  2, ZPX|NORM, },
  2021.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2022.     /* d8 */    { { 'C', 'L', 'D', 0, },  1, IMP|NORM, },
  2023.     /* d9 */    { { 'C', 'M', 'P', 0, },  3, ABY|NORM, },
  2024.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2025.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2026.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2027.     /* dd */    { { 'C', 'M', 'P', 0, },  3, ABX|NORM, },
  2028.     /* de */    { { 'D', 'E', 'C', 0, },  3, ABX|NORM, },
  2029.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2030.     /* e0 */    { { 'C', 'P', 'X', 0, },  2, IMM|NORM, },
  2031.     /* e1 */    { { 'S', 'B', 'C', 0, },  2, INX|NORM, },
  2032.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2033.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2034.     /* e4 */    { { 'C', 'P', 'X', 0, },  2, ZPG|NORM, },
  2035.     /* e5 */    { { 'S', 'B', 'C', 0, },  2, ZPG|NORM, },
  2036.     /* e6 */    { { 'I', 'N', 'C', 0, },  2, ZPG|NORM, },
  2037.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2038.     /* e8 */    { { 'I', 'N', 'X', 0, },  1, IMP|NORM, },
  2039.     /* e9 */    { { 'S', 'B', 'C', 0, },  2, IMM|NORM, },
  2040.     /* ea */    { { 'N', 'O', 'P', 0, },  1, IMP|NORM, },
  2041.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2042.     /* ec */    { { 'C', 'P', 'X', 0, },  3, ABS|NORM, },
  2043.     /* ed */    { { 'S', 'B', 'C', 0, },  3, ABS|NORM, },
  2044.     /* ee */    { { 'I', 'N', 'C', 0, },  3, ABS|NORM, },
  2045.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2046.     /* f0 */    { { 'B', 'E', 'Q', 0, },  2, REL|FORK, },
  2047.     /* f1 */    { { 'S', 'B', 'C', 0, },  2, INY|NORM, },
  2048.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2049.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2050.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2051.     /* f5 */    { { 'S', 'B', 'C', 0, },  2, ZPX|NORM, },
  2052.     /* f6 */    { { 'I', 'N', 'C', 0, },  2, ZPX|NORM, },
  2053.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2054.     /* f8 */    { { 'S', 'E', 'D', 0, },  1, IMP|NORM, },
  2055.     /* f9 */    { { 'S', 'B', 'C', 0, },  3, ABY|NORM, },
  2056.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2057.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2058.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2059.     /* fd */    { { 'S', 'B', 'C', 0, },  3, ABX|NORM, },
  2060.     /* fe */    { { 'I', 'N', 'C', 0, },  3, ABX|NORM, },
  2061.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  2062. };
  2063. SHAR_EOF
  2064. #    End of shell archive
  2065. exit 0
  2066. -- 
  2067. Bob Page, U of Lowell CS Dept.  page@swan.ulowell.edu  ulowell!page
  2068. Have five nice days.
  2069.